﻿#define _CRT_SECURE_NO_WARNINGS 1
//给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。
//不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
//说明 :
//为什么返回数值是整数，但输出的答案是数组呢 ?
//请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
//你可以想象内部操作如下 :
//// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
//int len = removeDuplicates(nums);
//
//// 在函数里修改输入数组对于调用者是可见的。
//// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
//for (int i = 0; i < len; i++) {
//	print(nums[i]);
//}
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/remove-duplicates-from-sorted-array
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int removeDuplicates(int* nums, int numsSize){
//	if (numsSize<2)
//	{
//		return numsSize;
//	}
//	int i = 0;
//	int j = 0;
//	for (i = 1; i<numsSize; i++)
//	{
//		if (nums[j] != nums[i])
//		{
//			nums[++j] = nums[i];
//		}
//	}
//	return j + 1;
//}








//实现 strStr() 函数。
//给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回  - 1 。
//说明：
//当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。
//对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与 C 语言的 strstr() 以及 Java 的 indexOf() 定义相符。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/implement-strstr
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int strStr(char * haystack, char * needle){
//	int len1 = strlen(haystack);
//	int len2 = strlen(needle);
//	int i = 0;
//	int j = 0;
//	int flag = 1;
//	for (i = 0; i + len2 <= len1; i++)
//	{
//		flag = 1;
//		for (j = 0; j<len2; j++)
//		{
//			if (haystack[i + j] != needle[j])
//			{
//				flag = 0;
//				break;
//			}
//		}
//		if (flag)
//		{
//			return i;
//		}
//	}
//	return -1;
//}







//
//给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
//int maxSubArray(int* nums, int numsSize){
//	int a = nums[0];
//	int b = 0;
//	int i = 0;
//	for (i = 0; i<numsSize; i++)
//	{
//		b = fmax(b + nums[i], nums[i]);
//		a = fmax(a, b);
//	}
//	return a;
//}








//给你一个字符串 s，由若干单词组成，单词之间用空格隔开。返回字符串中最后一个单词的长度。如果不存在最后一个单词，请返回 0 。
//单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/length-of-last-word
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int lengthOfLastWord(char * s){
//	int count = 0;
//	int len = strlen(s);
//	if (len == NULL)
//	{
//		return 0;
//	}
//	int i = 0;
//	for (i = len - 1; i >= 0; i--)
//	{
//		if (s[i] != ' ')
//		{
//			count++;
//		}
//		else if (s[i] == ' '&&count != 0)
//		{
//			break;
//		}
//	}
//	return count;
//}








/**给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/plus-one
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
* Note: The returned array must be malloced, assume caller calls free().
*/
//int* plusOne(int* digits, int digitsSize, int* returnSize){
//	int i = 0;
//	for (i = digitsSize - 1; i >= 0; i--)
//	{
//		if (digits[i] + 1 == 10)
//		{
//			digits[i] = 0;
//		}
//		else
//		{
//			digits[i] = digits[i] + 1;
//			*returnSize = digitsSize;
//			return digits;
//		}
//	}
//	*returnSize = digitsSize + 1;
//	int* a = (int*)malloc(sizeof(int)*(digitsSize + 1));
//	memset(a, 0, sizeof(int)*(digitsSize + 1));
//	a[0] = 1;
//	return a;
//}









//给你一个整数数组 nums （下标 从 0 开始 计数）以及两个整数 target 和 start ，请你找出一个下标 i ，满足 nums[i] == target 且 abs(i - start) 最小化 。注意：abs(x) 表示 x 的绝对值。
//
//返回 abs(i - start) 。
//
//题目数据保证 target 存在于 nums 中。
//
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/minimum-distance-to-the-target-element
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int getMinDistance(int* nums, int numsSize, int target, int start){
//	int min = INT_MAX;
//	int i = 0;
//	for (i = 0; i<numsSize; i++)
//	{
//		if (nums[i] == target)
//		{
//			min = fmin(min, abs(i - start));
//		}
//	}
//	return min;
//}







//给定两个字符串 s 和 t，它们只包含小写字母。
//
//字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。
//
//请找出在 t 中被添加的字母。
//char findTheDifference(char * s, char * t){
//	int i = 0;
//	int len1 = strlen(s);
//	int len2 = strlen(t);
//	int n = t[0] - 'a';
//	for (i = 0; i<len1; i++)
//	{
//		n ^= s[i] - 'a';
//	}
//	for (i = 1; i<len2; i++)
//	{
//		n ^= t[i] - 'a';
//	}
//	return n + 'a';
//}









//给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
//
//如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。
//
//假设环境不允许存储 64 位整数（有符号或无符号）。
//
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/reverse-integer
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int reverse(int x){
//	int n = 0;
//	while (x / 10)
//	{
//		n = n * 10 + x % 10;
//		x /= 10;
//	}
//	if ((n>INT_MAX / 10) || ((n == INT_MAX / 10) && (x>7)))
//	{
//		return 0;
//	}
//	else if ((n<INT_MIN / 10) || ((n == INT_MIN / 10) && (x<-8)))
//	{
//		return 0;
//	}
//	else
//	{
//		return n * 10 + x;
//	}
//}









//给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。
//
//回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。
//
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/palindrome-number
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//bool isPalindrome(int x){
//	if (x<0)
//	{
//		return 0;
//	}
//	long n = 0;
//	long tmp = x;
//	while (tmp>9)
//	{
//		n += tmp % 10;
//		n *= 10;
//		tmp /= 10;
//	}
//	n += tmp % 10;
//	if (n == x)
//	{
//		return 1;
//	}
//	return 0;
//}







//你现在是一场采用特殊赛制棒球比赛的记录员。这场比赛由若干回合组成，过去几回合的得分可能会影响以后几回合的得分。
//比赛开始时，记录是空白的。你会得到一个记录操作的字符串列表 ops，其中 ops[i] 是你需要记录的第 i 项操作，ops 遵循下述规则：
//整数 x - 表示本回合新获得分数 x
//"+" - 表示本回合新获得的得分是前两次得分的总和。题目数据保证记录此操作时前面总是存在两个有效的分数。
//"D" - 表示本回合新获得的得分是前一次得分的两倍。题目数据保证记录此操作时前面总是存在一个有效的分数。
//"C" - 表示前一次得分无效，将其从记录中移除。题目数据保证记录此操作时前面总是存在一个有效的分数。
//请你返回记录中所有得分的总和。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/baseball-game
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int calPoints(char ** ops, int opsSize){
//	int a[opsSize];
//	int count = 0;
//	int j = -1;
//	int i = 0;
//	for (i = 0; i<opsSize; i++)
//	{
//		switch (ops[i][0])
//		{
//		case '+':
//			a[++j] = a[j] + a[j - 1];
//			count += a[j];
//			break;
//		case 'D':
//			a[++j] = a[j] * 2;
//			count += a[j];
//			break;
//		case 'C':
//			count -= a[j--];
//			break;
//		default:
//			a[++j] = atoi(ops[i]);
//			count += a[j];
//		}
//	}
//	return count;
//}